package org.jypj.dev.service.impl;


import org.jypj.dev.dao.IThingDao;
import org.jypj.dev.model.Thing;
import org.jypj.dev.service.IThingService;
import org.jypj.dev.util.Page;
import org.jypj.dev.util.StringUtil;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.*;

@Service("thingService")
public class ThingServiceImpl implements IThingService {

    @Resource
    private IThingDao thingDao;

    /**
     * 保存
     * 字段为空的不存防止覆盖存在默认值的字段
     *
     * @param thing
     * @return 保存后的对象包括ID
     */
    public int saveThingByField(Thing thing) {
        if (StringUtil.isEmpty(thing.getId())) {
            String uuid = UUID.randomUUID().toString().replace("-", "").trim();
            thing.setId(uuid);
        }
        return thingDao.saveThingByField(thing);
    }

    /**
     * 保存
     * 所有字段全都保存
     *
     * @param thing
     * @return 保存后的对象包括ID
     */
    public int saveThing(Thing thing) {
        if (StringUtil.isEmpty(thing.getTrainCode())) {
            thing.setTrainCode("备品备件");
        }
        if (StringUtil.isEmpty(thing.getTrainNum())) {
            thing.setTrainNum("备品备件");
        }
        return thingDao.saveThing(thing);
    }

    /**
     * 根据ID删除
     *
     * @param id 主键ID
     * @return 删除记录数
     */
    public int deleteThingById(String id) {

        return thingDao.deleteThingById(id);
    }

    /**
     * 根据对象删除
     *
     * @param id 主键ID
     * @return
     */
    public int deleteThingByObject(Thing thing) {

        return thingDao.deleteThingByObject(thing);
    }

    /**
     * 更新
     * 只更新值不为空的字段
     *
     * @param thing
     * @return 保存后的对象包括ID
     */
    public int updateThingByField(Thing thing) {

        return thingDao.updateThingByField(thing);
    }

    /**
     * 更新
     * 更新所有字段
     *
     * @param thing
     * @return 保存后的对象包括ID
     */
    public int updateThing(Thing thing) {

        return thingDao.updateThing(thing);
    }

    /**
     * 按ID查询
     *
     * @return Thing
     * @parm id 主键ID
     */
    public Thing selectThingById(String id) {

        return thingDao.selectThingById(id);
    }

    /**
     * 分页查询 包含条件
     *
     * @param page 分页对象
     * @param map  查询条件
     * @return List<Thing>
     */
    public Page selectOnePageByMap(Page page, Map<String, Object> map) {
        List<Thing> things = thingDao.selectOnePageByMap(page, map);
        if (things != null && things.size() > 0) {
            page.setResult(things);
        } else {
            page.setResult(new ArrayList<Thing>());
        }
        return page;
    }

    /**
     * 分页查询 包含对象条件
     *
     * @param page  分页对象
     * @param thing 查询条件
     * @return Page
     */
    public Page selectOnePageByThing(Page page, Thing thing) {
        List<Thing> things = thingDao.selectOnePageByThing(page, thing);
        if (things != null && things.size() > 0) {
            page.setResult(things);
        } else {
            page.setResult(new ArrayList<Thing>());
        }
        return page;
    }

    /**
     * 按条件查询全部的
     *
     * @param map 查询条件
     * @return List<Thing>
     */
    public List<Thing> selectAllByMap(Map<String, Object> map) {
        return thingDao.selectAllByMap(map);
    }


    /**
     * 按条件查询全部的
     *
     * @param map 查询条件
     * @return List<Thing>
     */
    public List<Thing> selectAllByThing(Thing thing) {

        return thingDao.selectAllByThing(thing);
    }

    /**
     * 按条件查询单个对象
     *
     * @param map 查询条件
     * @return Thing
     */
    public Thing selectObjectByMap(Map<String, Object> map) {

        return thingDao.selectObjectByMap(map);
    }

    /**
     * 按条件查询单个对象
     *
     * @param map 查询条件
     * @return Thing
     */
    public Thing selectObjectByThing(Thing thing) {

        return thingDao.selectObjectByThing(thing);
    }
}